Comment rapporter efficacement des fenêtres coulissantes d'une durée fixe en secondes

Je pense que vous vouliez dire incrément basé sur "Pour chaque fenêtre de longueur 2 secondes commençant à une deuxième limite" et non pas de chevauchement. Pour deux secondes d'intervalle, c'est la même chose, mais comme vous voulez faire varier la longueur, un chevauchement d'une seconde serait de 0-3, 2-5, 4-7, mais l'incrément signifierait 0-3, 1-4, 2- 5. Cependant, il était intéressant de trouver des solutions pour les deux au cas où.
En supposant que L est trié et que tous les éléments sont positifs et que les seconds intervalles commencent tous par des entiers, nous pouvons utiliser cette méthode:
importer des mathématiques
à partir de collections importer defaultdict
L = [0,10218048, 1,20851996, 1,46800021, 1,73429061, 2,71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6.80623747, 6.99571917, 7.65215123, 7.86108352, 8.52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
my_ranges = defaultdict (liste)
interval_width = 2
pour x en L:
borne_upérieure = math.ceil (x)
lower_bound = upper_bound - largeur_intervalle
limite_ inférieure = max (0, limite_ inférieure)
pour y dans la plage (limite inférieure, limite supérieure):
mes_plages [y] .append (x)
pour un in trié (my_ranges):
print (my_ranges [a])
Je ne sais pas si vous voulez voir s'il y a des plages vides. Mais le defaultdict imprime également des plages vides si vous le souhaitez. Utilisez cette ligne au lieu de "pour un trié":
pour un in range (min (my_ranges), max (my_ranges) + 1):
Si vous vouliez les plages 0-3, 2-5, 4-7, cela fonctionne:
importer des mathématiques
à partir de collections importer defaultdict
L = [0,10218048, 1,20851996, 1,46800021, 1,73429061, 2,71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6.80623747, 6.99571917, 7.65215123, 7.86108352, 8.52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
interval_width = 2
my_ranges_2 = defaultdict (liste)
pour x en L:
définitivement_in = (x // (interval_width - 1)) * (interval_width - 1) # le plus petit multiple de interval_width en dessous de x sera toujours
#print ("Ajout", x, "à", définitivement_in)
my_ranges_2 [définitivement_in] .append (x)
si x  = 0: # par exemple, si x vaut 2,3 et que nous avons 0,3 2,5 etc. Je suppose que les longueurs de fenêtre sont des nombres entiers, et sinon, nous avons beaucoup plus à faire, car le nombre peut aller dans plus d'un tableau. Peut-être que nous pourrions avoir une boucle while, incrémentée de (interval_width - 1)
#print ("++ Ajout de", x, "à", définitivement_in - largeur_intervalle + 1)
my_ranges_2 [définitivement_in - largeur_intervalle + 1] .append (x)
pour un in trié (my_ranges_2):
print (a, my_ranges_2 [a])
# print (my_ranges_2 [a])
Je soupçonne que j'ai oublié certains détails, mais j'espère que vous pourrez modifier interval_width au besoin pour vous assurer que mon code fait ce que vous espériez et me faire savoir ce dont vous avez besoin.
|
Une solution possible que je peux proposer est «efficace» en un sens, car elle n'itère qu'une seule fois à travers les données d'entrée et n'a pas de dépendances. Le coût, bien sûr, est qu'il est écrit en python pur (il pourrait y avoir du code plus optimisé) et qu'il introduit plus de variables de suivi pour éviter la réitération (et donc moins pythonique).
def glissant_window (données, durée, début = 0, chevauchement = 1):
résultat = []
data_idx = 0
result_idx = 0
supérieur = début + durée
inférieur = début
next_lower = supérieur - chevauchement
# assistant interne pour remplir les listes internes vides jusqu'à notre point d'insertion et insérer
def pad_and_append (at):
tandis que len (résultat) <= at:
result.append ([])
result [at] .append (données [data_idx])
# itérer dans les données d'entrée
while data_idx  a:
si x  = l [0]) & (L  = i) & (L